home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 44 / PC Actual CD 44.iso / Linux / Cygwin / full.exe / Disk1 / data1.cab / Tools / share / dejagnu / config / gdb-comm.exp < prev    next >
Encoding:
Text File  |  1998-12-04  |  15.1 KB  |  539 lines
  1. # Copyright (C) 1996, 1997 Free Software Foundation, Inc.
  2.  
  3. # This program is free software; you can redistribute it and/or modify
  4. # it under the terms of the GNU General Public License as published by
  5. # the Free Software Foundation; either version 2 of the License, or
  6. # (at your option) any later version.
  7. # 
  8. # This program is distributed in the hope that it will be useful,
  9. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. # GNU General Public License for more details.
  12. # 
  13. # You should have received a copy of the GNU General Public License
  14. # along with this program; if not, write to the Free Software
  15. # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  16.  
  17. # Please email any bugs, comments, and/or additions to this file to:
  18. # DejaGnu@cygnus.com
  19.  
  20. # Note: some of this was cribbed from the gdb testsuite since we need
  21. # to use some pretty standard gdb features (breakpoints in particular).
  22.  
  23. # Load up some standard junk.
  24. load_lib remote.exp
  25.  
  26. if ![info exists board] {
  27.     perror "$board must be set before loading gdb-comm"
  28. }
  29.  
  30. # The number of times we've tried to download/execute this executable.
  31. set try_again 0
  32.  
  33. #
  34. # Delete all breakpoints and verify that they were deleted.  If anything
  35. # goes wrong, return -1.
  36. #
  37. proc gdb_comm_delete_breakpoints {} {
  38.     global gdb_prompt
  39.  
  40.     remote_send host "delete breakpoints\n";
  41.     remote_expect host 10 {
  42.     -re "Delete all breakpoints.*y or n. $" {
  43.         remote_send host "y\n"
  44.         exp_continue
  45.     }
  46.     -re ".*$gdb_prompt $" { }
  47.     timeout { perror "Delete all breakpoints (timeout)" ; return -1}
  48.     }
  49.     remote_send host "info breakpoints\n"
  50.     remote_expect host 10 {
  51.     -re "No breakpoints or watchpoints..*$gdb_prompt $" {}
  52.     -re ".*$gdb_prompt $" { perror "breakpoints not deleted" ; return -1}
  53.     timeout { perror "info breakpoints (timeout)" ; return -1}
  54.     }
  55.     return 0;
  56. }
  57.  
  58. #
  59. # Inform the debugger that we have a new exec file.
  60. # return a -1 if anything goes wrong, 0 on success.
  61. #
  62. proc gdb_comm_file_cmd { arg } {
  63.     global verbose
  64.     global loadpath
  65.     global loadfile
  66.     global GDB
  67.     global gdb_prompt
  68.     upvar timeout timeout
  69.  
  70.     # The "file" command loads up a new symbol file for gdb, deal with
  71.     # the various messages it might spew out.
  72.     if [is_remote host] {
  73.     set arg [remote_download host $arg a.out];
  74.     }
  75.     remote_send host "file $arg\n"
  76.     remote_expect host 60 {
  77.         -re "Reading symbols from.*done.*$gdb_prompt $" {
  78.             verbose "\t\tLoaded $arg into the $GDB"
  79.             return 0
  80.         }
  81.         -re "has no symbol-table.*$gdb_prompt $" {
  82.             perror "$arg wasn't compiled with \"-g\""
  83.             return -1
  84.         }
  85.         -re "A program is being debugged already.*Kill it.*y or n. $" {
  86.             remote_send host "y\n"
  87.         verbose "\t\tKilling previous program being debugged"
  88.             exp_continue
  89.         }
  90.         -re "Load new symbol table from \".*\".*y or n.*$" {
  91.             remote_send host "y\n"
  92.             remote_expect host 60 {
  93.                 -re "Reading symbols from.*done.*$gdb_prompt $" {
  94.                     verbose "\t\tLoaded $arg with new symbol table into $GDB"
  95.                     return 0
  96.                 }
  97.                 timeout {
  98.                     perror "(timeout) Couldn't load $arg, other program already loaded."
  99.                     return -1
  100.                 }
  101.             }
  102.     }
  103.         -re ".*No such file or directory.*$gdb_prompt $" {
  104.             perror "($arg) No such file or directory\n"
  105.             return -1
  106.         }
  107.         -re "$gdb_prompt $" {
  108.             perror "couldn't load $arg into $GDB."
  109.             return -1
  110.             }
  111.         timeout {
  112.             perror "couldn't load $arg into $GDB (timed out)."
  113.             return -1
  114.         }
  115.     eof {
  116.             # This is an attempt to detect a core dump, but seems not to
  117.             # work.  Perhaps we need to match .* followed by eof, in which
  118.             # expect does not seem to have a way to do that.
  119.             perror "couldn't load $arg into $GDB (end of file)."
  120.             return -1
  121.         }
  122.     }
  123.     return 0;
  124. }
  125.  
  126. # Disconnect from the target and forget that we have an executable. Returns
  127. # -1 on failure, 0 on success.
  128.  
  129. proc gdb_comm_go_idle { } {
  130.     global gdb_prompt;
  131.  
  132.     if ![board_info host exists fileid] {
  133.     return -1;
  134.     }
  135.  
  136.     remote_send host "target exec\n";
  137.     remote_expect host 10 {
  138.     -re "Kill it.*y or n.*$" {
  139.         remote_send host "y\n"
  140.         exp_continue;
  141.     }
  142.     -re "No exec file now.*$gdb_prompt $" { 
  143.         return 0;
  144.     }
  145.     default {
  146.         remote_close host;
  147.         return -1;
  148.     }
  149.     }
  150. }
  151.  
  152. # Start GDB running with target DEST.
  153. proc gdb_comm_start { dest } {
  154.     global GDB
  155.     global gdb_prompt
  156.     global tool_root_dir
  157.  
  158.     # The variable gdb_prompt is a regexp which matches the gdb prompt.  Set it
  159.     # if it is not already set.
  160.     if ![board_info $dest exists gdb_prompt] then {
  161.     set gdb_prompt "\\(gdb\\)"
  162.     } else {
  163.     set gdb_prompt [board_info $dest gdb_prompt];
  164.     }
  165.     # Similarly for GDB.  Look in the object directory for gdb if we aren't
  166.     # provided with one.
  167.     if ![info exists GDB] then {
  168.     set GDB "[lookfor_file ${tool_root_dir} gdb/gdb]"
  169.     if { $GDB == "" } {
  170.         set GDB [transform gdb]
  171.     }
  172.     }
  173.     if [board_info host exists gdb_opts] {
  174.     set gdb_opts [board_info host gdb_opts];
  175.     } else {
  176.     set gdb_opts ""
  177.     }
  178.     # Start up gdb (no startfiles, no windows) and wait for a prompt.
  179.     remote_spawn host "$GDB $gdb_opts -nw -nx";
  180.     remote_expect host 60 {
  181.     -re ".*$gdb_prompt $" { }
  182.     }
  183.     remote_send host "set height 0\n";
  184.     remote_expect host 10 {
  185.     -re ".*$gdb_prompt $" {}
  186.     }
  187.     remote_send host "set width 0\n";
  188.     remote_expect host 10 {
  189.     -re ".*$gdb_prompt $" {}
  190.     }
  191. }
  192.  
  193. # Add a breakpoint at function FUNCTION. We assume that GDB has already been
  194. # started.
  195. proc gdb_comm_add_breakpoint { function } {
  196.     global gdb_prompt
  197.  
  198.     remote_send host "break $function\n"
  199.     remote_expect host 60 {
  200.     -re "Breakpoint.*$gdb_prompt $" { return "" }
  201.     -re "Function.*not defined.*$gdb_prompt $" { return "undef" }
  202.     -re "No symbol table.*$gdb_prompt $" { return "undef" }
  203.     default {
  204.         return "untested"
  205.     }
  206.     }
  207. }
  208.  
  209. #
  210. # quit_gdb -- try to quit GDB gracefully
  211. #
  212.  
  213. proc quit_gdb { } {
  214.     global gdb_prompt;
  215.  
  216.     set spawn_id [board_info host fileid];
  217.  
  218.     if { $spawn_id != "" && $spawn_id > -1 } {
  219.     if { [remote_send host "quit\n"] == "" } {
  220.         remote_expect host 10 {
  221.         -re ".*y or n.*$" {
  222.             remote_send host "y\n";
  223.             exp_continue;
  224.         }
  225.         -re ".*\[*\]\[*\]\[*\].*EXIT code" { }
  226.         default { }
  227.         }
  228.     }
  229.     }
  230.     remote_close host;
  231. }
  232.  
  233. proc gdb_comm_leave { } {
  234.     if [is_remote host] {
  235.     quit_gdb;
  236.     } else {
  237.     gdb_comm_go_idle;
  238.     }
  239. }
  240. #
  241. # gdb_comm_load -- load the program and execute it
  242. #
  243. # PROG is a full pathname to the file to load, no arguments.
  244. # Result is "untested", "pass", "fail", etc.
  245. #
  246.  
  247. proc gdb_comm_load { dest prog args } {
  248.     global GDB
  249.     global GDBFLAGS
  250.     global gdb_prompt
  251.     global timeout
  252.     set argnames { "command-line arguments" "input file" "output file" }
  253.  
  254.     for { set x 0; } { $x < [llength $args] } { incr x } {
  255.     if { [lindex $args $x] != "" } {
  256.         return [list "unsupported" "no support for [lindex $argnames $x] on this target"];
  257.     }
  258.     }
  259.     # Make sure the file we're supposed to load really exists.
  260.     if ![file exists $prog] then {
  261.     perror "$prog does not exist."
  262.         return [list "untested" ""];
  263.     }
  264.  
  265.     if { [is_remote host] || ![board_info host exists fileid] } {
  266.     gdb_comm_start $dest;
  267.     }
  268.  
  269.     # Remove all breakpoints, then tell the debugger that we have
  270.     # new exec file.
  271.     if { [gdb_comm_delete_breakpoints] != 0 } {
  272.     gdb_comm_leave;
  273.     return [gdb_comm_reload $dest $prog $args];
  274.     }
  275.     if { [gdb_comm_file_cmd $prog] != 0 } {
  276.     gdb_comm_leave;
  277.     return [gdb_comm_reload $dest $prog $args];
  278.     }
  279.     if [board_info $dest exists gdb_sect_offset] {
  280.     set textoff [board_info $dest gdb_sect_offset];
  281.     remote_send host "sect .text $textoff\n";
  282.     remote_expect host 10 {
  283.         -re "(0x\[0-9a-z]+) - 0x\[0-9a-z\]+ is \\.data" {
  284.         set dataoff $expect_out(1,string);
  285.         exp_continue;
  286.         }
  287.         -re "(0x\[0-9a-z\]+) - 0x\[0-9a-z\]+ is \\.bss" {
  288.         set bssoff $expect_out(1,string);
  289.         exp_continue;
  290.         }
  291.         -re "$gdb_prompt" { }
  292.     }
  293.     set dataoff [format 0x%x [expr $dataoff + $textoff]];
  294.     set bssoff [format 0x%x [expr $bssoff + $textoff]];
  295.     remote_send host "sect .data $dataoff\n";
  296.     remote_expect host 10 {
  297.         -re "$gdb_prompt" { }
  298.     }
  299.     remote_send host "sect .bss $bssoff\n";
  300.     remote_expect host 10 {
  301.         -re "$gdb_prompt" { }
  302.     }
  303.     }
  304.  
  305.     # Now set up breakpoints in exit, _exit, and abort.  These
  306.     # are used to determine if a c-torture test passed or failed.  More
  307.     # work would be necessary for things like the g++ testsuite which
  308.     # use printf to indicate pass/fail status.
  309.  
  310.     if { [gdb_comm_add_breakpoint _exit] != "" } {
  311.     gdb_comm_add_breakpoint exit;
  312.     }
  313.     gdb_comm_add_breakpoint abort;
  314.  
  315.     set protocol [board_info $dest gdb_protocol];
  316.     if [board_info $dest exists gdb_serial] {
  317.     set targetname [board_info $dest gdb_serial];
  318.     } elseif [board_info $dest exists netport] {
  319.     set targetname [board_info $dest netport];
  320.     } else {
  321.     if [board_info $dest exists serial] {
  322.         set targetname [board_info $dest serial];
  323.     } else {
  324.         set targetname ""
  325.     }
  326.     }
  327.     if [board_info $dest exists baud] {
  328.     remote_send host "set remotebaud [board_info $dest baud]\n"
  329.     remote_expect host 10 {
  330.         -re ".*$gdb_prompt $" {}
  331.         default {
  332.         warning "failed setting baud rate";
  333.         }
  334.     }
  335.     }
  336.     remote_send host "target $protocol $targetname\n";
  337.     remote_expect host 60 {
  338.     -re "Couldn.t establish conn.*$gdb_prompt $" {
  339.         warning "Unable to connect to $targetname with GDB."
  340.         quit_gdb;
  341.         return [gdb_comm_reload $dest $prog $args]
  342.     }
  343.     -re "Ending remote.*$gdb_prompt $" {
  344.         warning "Unable to connect to $targetname with GDB."
  345.         quit_gdb;
  346.         return [gdb_comm_reload $dest $prog $args]
  347.     }
  348.     -re "Remote target $protocol connected to.*$gdb_prompt $" { }
  349.     -re "Remote target $targetname connected to.*$gdb_prompt $" { }
  350.     -re "Connected to ARM RDI target.*$gdb_prompt $" { }
  351.     -re "Connected to the simulator.*$gdb_prompt $" { }
  352.     -re "Remote.*using $targetname.*$gdb_prompt $" { }
  353.     -re "$gdb_prompt $" {
  354.         warning "Unable to connect to $targetname with GDB."
  355.         quit_gdb;
  356.         return [gdb_comm_reload $dest $prog $args]
  357.     }
  358.     -re ".*RDI_open.*should reset target.*" {
  359.         warning "RDI Open Failed"
  360.         quit_gdb;
  361.         return [gdb_comm_reload $dest $prog $args]
  362.     }
  363.     default {
  364.         warning "Unable to connect to $targetname with GDB."
  365.         quit_gdb;
  366.         return [gdb_comm_reload $dest $prog $args]
  367.     }
  368.     }
  369.  
  370.     if [target_info exists gdb_init_command] {
  371.     remote_send host "[target_info gdb_init_command]\n";
  372.     remote_expect host 10 {
  373.         -re ".*$gdb_prompt $" { }
  374.         default {
  375.         gdb_comm_leave;
  376.         return [list "fail" ""];
  377.         }
  378.     }
  379.     }
  380.     # Now download the executable to the target board.  If communications
  381.     # with the target are very slow the timeout might need to be increased.
  382.     if [board_info $dest exists gdb_load_offset] {
  383.     remote_send host "load $prog [board_info $dest gdb_load_offset]\n";
  384.     } else {
  385.     remote_send host "load\n"
  386.     }
  387.     remote_expect host 600 {
  388.     -re "text.*data.*$gdb_prompt $" { }
  389.     -re "data.*text.*$gdb_prompt $" { }
  390.     -re "$gdb_prompt $" {
  391.         warning "Unable to send program to target board."
  392.         gdb_comm_leave;
  393.         return [gdb_comm_reload $dest $prog $args];
  394.     }
  395.     default {
  396.         warning "Unable to send program to target board."
  397.         gdb_comm_leave;
  398.         return [gdb_comm_reload $dest $prog $args];
  399.     }
  400.     }
  401.  
  402.     set output ""
  403.     
  404.     # Now start up the program and look for our magic breakpoints.
  405.     # And a whole lot of other magic stuff too.
  406.  
  407.     if [board_info $dest exists gdb_run_command] {
  408.     remote_send host "[board_info $dest gdb_run_command]\n";
  409.     } else {
  410.     remote_send host "run\n"
  411.     }
  412.     # FIXME: The value 300 below should be a parameter.
  413.     if [board_info $dest exists testcase_timeout] {
  414.     set testcase_timeout [board_info $dest testcase_timeout];
  415.     } else {
  416.     set testcase_timeout 300;
  417.     }
  418.     remote_expect host $testcase_timeout {
  419.     -re "Line.*Jump anyway.*.y or n.*" {
  420.         remote_send host "y\n";
  421.         exp_continue;
  422.     }
  423.     -re "Continuing( at |\\.| with no signal\\.)\[^\r\n\]*\[\r\n\]" {
  424.         exp_continue;
  425.     }
  426.     -re ".*Start it from the beginning?.*y or n.*" {
  427.         remote_send host "n\n";
  428.         remote_expect host 10 {
  429.         -re ".*$gdb_prompt $" {
  430.             remote_send host "signal 0\n";
  431.             remote_expect host 10 {
  432.             -re "signal 0\[\r\n\]+" { exp_continue; }
  433.             -re "Continuing(\\.| with no signal\\.)\[\r\n\]" {}
  434.             }
  435.         }
  436.         }
  437.         exp_continue
  438.     }
  439.     -re "(run\[\r\n\]*|)Starting program: \[^\r\n\]*\[\r\n\]" {
  440.         exp_continue
  441.     }
  442.     -re "$gdb_prompt (signal 0|continue)\[\r\n\]+Continuing(\\.| with no signal\\.)\[\r\n\]" {
  443.         exp_continue
  444.     }
  445.     -re "(.*)Breakpoint.*exit.*=0.*$gdb_prompt $" {
  446.         append output $expect_out(1,string);
  447.         set result [check_for_board_status output];
  448.         gdb_comm_leave;
  449.         if { $result > 0 } {
  450.         return [list "fail" $output];
  451.         }
  452.         return [list "pass" $output];
  453.     }
  454.     -re "(.*)Breakpoint.*exit.*=\[1-9\]\[0-9\]*.*$gdb_prompt $" {
  455.         append output $expect_out(1,string);
  456.         set result [check_for_board_status output];
  457.         gdb_comm_leave;
  458.         if { $result == 0 } {
  459.         return [list "pass" $output];
  460.         }
  461.         if [board_info $dest exists exit_statuses_bad] {
  462.         return [list "pass" $output];
  463.         }
  464.         return [list "fail" $output];
  465.     }
  466.     -re "(.*)Breakpoint.*exit.*$gdb_prompt $" {
  467.         append output $expect_out(1,string);
  468.         set status [check_for_board_status output];
  469.         gdb_comm_leave;
  470.         if { $status > 0 } {
  471.         return [list "fail" $output];
  472.         }
  473.         return [list "pass" $output];
  474.     }
  475.     -re "(.*)Breakpoint.*abort.*$gdb_prompt $" {
  476.         append output $expect_out(1,string);
  477.         check_for_board_status output;
  478.         gdb_comm_leave;
  479.         return [list "fail" $output];
  480.     }
  481.     -re "SIGTRAP.*$gdb_prompt $" {
  482.         return [gdb_comm_reload $dest $prog $args];
  483.     }
  484.     -re "(.*)Program (received |terminated ).*$gdb_prompt $" {
  485.         set output $expect_out(1,string);
  486.         check_for_board_status output;
  487.         gdb_comm_leave;
  488.         remote_reboot $dest;
  489.         return [list "fail" $output];
  490.     }
  491.     -re "(.*)Program exited with code \[0-9\]+.*$gdb_prompt $" {
  492.         set output $expect_out(1,string);
  493.         set status [check_for_board_status output];
  494.         gdb_comm_leave;
  495.         if { $status > 0 } {
  496.         return [list "fail" $output];
  497.         }
  498.         return [list "pass" $output];
  499.     }
  500.     default {
  501.         gdb_comm_leave;
  502.         if [board_info $dest exists unreliable] {
  503.         if { [board_info $dest unreliable] > 0 } {
  504.             global board_info;
  505.             set name [board_info $dest name];
  506.             incr board_info($name,unreliable) -1;
  507.             set result [gdb_comm_reload $dest $prog $args];
  508.             incr board_info($name,unreliable);
  509.             return $result;
  510.         }
  511.         }
  512.         return [list "fail" ""];
  513.     }
  514.     }
  515.     gdb_comm_leave;
  516.     return [list "fail" ""];
  517. }
  518.  
  519. # If we've tried less than 4 times to load PROG, reboot the target, restart GDB
  520. # and try again. Otherwise, return "untested".
  521. proc gdb_comm_reload { dest prog aargs } {
  522.     global try_again;
  523.  
  524.     if { $try_again < 4 } {
  525.     global GDB;
  526.     remote_reboot $dest;
  527.     remote_close host;
  528.     incr try_again;
  529.     set result [eval remote_load \"$dest\" \"$prog\" $aargs]
  530.     set try_again 0;
  531.     return "$result";
  532.     } else {
  533.     set try_again 0;
  534.     return [list "untested" ""];
  535.     }
  536. }
  537.  
  538. set_board_info protocol  "gdb_comm";
  539.